# 💚 04. 스트림(Stream) 활용 | slice | map | match | find | reduce | ...

🤨 본격적으로 스트림을 활용해보자! 먼저, DISH 클래스와 MainMethod를 생성해주자.

# 🍽️ DISH 클래스

package javaStudy;

public class Dish {

    private final String name;
    private final boolean vegetarian;
    private final int calories;
    private final Type type;

    public Dish(String name, boolean vegetarian, int calories, Type type) {
        this.name = name;
        this.vegetarian = vegetarian;
        this.calories = calories;
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public boolean isVegetarian() {
        return vegetarian;
    }

    public int getCalories() {
        return calories;
    }

    public Type getType() {
        return type;
    }

    public enum Type {
        MEAT,
        FISH,
        OTHER
    }

    @Override
    public String toString() {
        return "Dish{" +
                "name='" + name + '\'' +
                ", vegetarian=" + vegetarian +
                ", calories=" + calories +
                ", type=" + type +
                '}';
    }
}

package javaStudy.mda05;

import javaStudy.Dish;

import java.util.Arrays;
import java.util.List;

public class MainMethod {

    public static List<Dish> menu = Arrays.asList(
            new Dish("pork", false, 800, Dish.Type.MEAT),
            new Dish("beef", false, 700, Dish.Type.MEAT),
            new Dish("chicken", false, 400, Dish.Type.MEAT),
            new Dish("french fries", true, 530, Dish.Type.OTHER),
            new Dish("rice", true, 350, Dish.Type.OTHER),
            new Dish("season fruit", true, 120, Dish.Type.OTHER),
            new Dish("pizza", true, 550, Dish.Type.OTHER),
            new Dish("prawns", false, 300, Dish.Type.FISH),
            new Dish("salmon", false, 450, Dish.Type.FISH)
    );
    
    public static void main(String[] args) {
        
    }
}

# 💎 필터링

스트림 인터페이스는 filter 메소드를 지원한다. Predicate를 인수로 받아서 일치하는 모든 요소를 포함하는 스트림을 반환한다.

// [Dish{name='french fries', vegetarian=true, calories=530, type=OTHER}, Dish{name='rice', vegetarian=true, calories=350, type=OTHER}, Dish{name='season fruit', vegetarian=true, calories=120, type=OTHER}, Dish{name='pizza', vegetarian=true, calories=550, type=OTHER}]
List<Dish> vegetarianMenu = menu.stream().filter(Dish::isVegetarian).collect(toList());

# 고유 요소로 필터링

고유 요소로 이루어진 스트림을 반환하는 distinct 메소드도 지원한다.

//2
//4
List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
        numbers.stream()
                .filter(i -> i % 2 == 0)
                .distinct()
                .forEach(System.out::println);

# 💎 스트림 슬라이싱

Java 9 은 스트림의 요소를 효과적으로 선택할 수 있도록 takeWhile dropWhile 두가지 새로운 메소드를 지원한다.

# takeWhile

이미 정렬된 List를 필터링하였을 경우, 반복 작업이 생길 수 있다. 이때 사용하는 게 takeWhile이다. 참이 되는 요소까지만 포함하도록 한다.

아래와 같은 경우, 칼로리 순으로 정렬되어 있다는 사실을 확인하여 400칼로리 이하일때까지만 스트림을 포함하도록 하였다.

List<Dish> specialMenu = Arrays.asList(
                new Dish("season fruit", true, 120, Dish.Type.OTHER),
                new Dish("rice", true, 350, Dish.Type.OTHER),
                new Dish("chicken", false, 400, Dish.Type.MEAT),
                new Dish("salmon", false, 450, Dish.Type.FISH),
                new Dish("french fries", true, 530, Dish.Type.OTHER),
                new Dish("beef", false, 700, Dish.Type.MEAT));

//[Dish{name='season fruit', vegetarian=true, calories=120, type=OTHER}, Dish{name='rice', vegetarian=true, calories=350, type=OTHER}]
List<Dish> slicedMenu1
        = specialMenu.stream()
					.takeWhile(dish -> dish.getCalories() < 400)
					.collect(toList());

# dropWhile

dropWhile은 takeWhile과 정반대의 작업을 수행한다. 거짓이 되는 지점까지 발견된 요소를 버린다.

// [Dish{name='chicken', vegetarian=false, calories=400, type=MEAT}, Dish{name='salmon', vegetarian=false, calories=450, type=FISH}, Dish{name='french fries', vegetarian=true, calories=530, type=OTHER}, Dish{name='beef', vegetarian=false, calories=700, type=MEAT}]
List<Dish> slicedMenu2
          = specialMenu.stream()
						.dropWhile(dish -> dish.getCalories() < 400)
						.collect(toList());

# 스트림 축소

// [Dish{name='chicken', vegetarian=false, calories=400, type=MEAT}, Dish{name='salmon', vegetarian=false, calories=450, type=FISH}, Dish{name='french fries', vegetarian=true, calories=530, type=OTHER}]
List<Dish> limitDishes
          = specialMenu.stream()
            .filter(dish -> dish.getCalories() > 350)
            .limit(3) // 3개 반환
            .collect(toList());

# 요소 건너뛰기

// [Dish{name='french fries', vegetarian=true, calories=530, type=OTHER}, Dish{name='beef', vegetarian=false, calories=700, type=MEAT}]
List<Dish> skipDishes
          = specialMenu.stream()
	          .filter(dish -> dish.getCalories() > 350)
	          .skip(2) // 처음 2개 요소 제외하고 반환
	          .collect(toList());

# 💎 매핑 (map)

특정 객체에서 특정 데이터를 선택하는 작업! 자주 수행되는 연산이므로 유용할 거 같다.

# 스트림의 각 요소에 함수 적용

각 요소에 적용한 결과가 새로운 요소로 매핑된다.

// [pork, beef, chicken, french fries, rice, season fruit, pizza, prawns, salmon]
List<String> dishNames
                = menu.stream()
	                .map(Dish::getName)
	                .collect(toList());

// [4, 4, 7, 12, 4, 12, 5, 6, 6]
List<Integer> dishNameLengths
                = menu.stream()
	                .map(Dish::getName)
	                .map(String::length)
	                .collect(toList());

# 스트림 평면화

List에서 고유문자로 이루어진 List를 반환해보자.

아래와 같이 생각할 수 있을 것이다.


List<String> words = Arrays.asList("Hello", "world");
List<String[]> distinct
							= words.stream()
					      .map(s -> s.split(""))
					      .distinct()
					      .collect(toList());

하지만 위 방법은 Stream<String[]> 을 반환할 뿐더러 Hello 와 World 로 String[]이 담겨 고유문자를 반환하지도 않는다... 우리가 원하는 것은 Stream<String> 이다ㅠㅠ

# map과 Arrays.stream (opens new window) 활용

문자열을 받아 Stream을 만들어주는 Arrays.stream()메서드가 있다.

String[] arrayOfWords = {"Goodbye", "World"};
Stream<String> streamOfwords = Arrays.stream(arrayOfWords);

List<String> words = Arrays.asList("Hello", "world");
List<Stream<String>> distinct
							= words.stream()
					      .map(s -> s.split(""))
								.map(Arrays::stream)
					      .distinct()
					      .collect(toList());

하지만 위 메소드도 List<Stream<String>>이 만들어져서 문제가 해결되지 않았다.

# flapMap

flatMap을 사용하면 다음처럼 문제 해결 가능!

// [H, e, l, o, w, r, d]
List<String> distinct =
                words.stream()
                .map(s -> s.split(""))
                .flatMap(Arrays::stream)// 생성된 스트림을 하나의 스트림으로 평면화
                .distinct()
                .collect(toList());

# 💎 검색과 매칭

특정 속성이 데이터 집합에 있는지 여부를 검색하는 데이터 처리

# anyMatch()

Predicate가 주어진 스트림에서 적어도 한 요소와 일치하는지 확인할 때

if (menu.stream().anyMatch(Dish::isVegetarian)) {
    System.out.println("The menu is vegetarian friendly");
}

# allMatch()

모든 요소가 주어진 Predicate와 일치하는지 확인할 때

// true
boolean isHealthy = menu.stream()
                        .allMatch(dish -> dish.getCalories() < 1000);

# noneMatch()

allMatch와 반대라고 생각하면 된다. 위 메소드를 아래와 같이 다시 구현할 수 있다.

// true
boolean isHealthy = menu.stream()
                        .noneMatch(dish -> dish.getCalories() >= 1000);

# findAny()

현재 스트림에서 일치하는 임의의 요소를 반환한다.

Optional<Dish> dish = menu.stream()
                      .filter(Dish::isVegetarian)
                      .findAny();

# findFirst()

첫번째 요소를 반환한다.

List<Integer> someNumbers = Arrays.asList(1,2,3,4,5);
Optional<Integer> firstSquareDivisibleByThree =
        someNumbers.stream()
                .map(n -> n * n)
                .filter(n -> n % 3 == 0)
                .findFirst();

# 💎 리듀싱 (Reduce)

"메뉴의 모든 칼로리의 합계를 구하시오" 같이 스트림 요소를 조합해서 더 복잡한 질의를 표현하는 방법에 대해 알아보자.

# 요소의 합/곱

reduce 는 2개의 인수를 갖는다.

📌 초깃값 0

📌 두 요소를 조합해서 새로운 값을 만드는 BinaryOperator<T> 예제에서는 람다표현식 사용

List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5);
int sum = numberList.stream().reduce(0, (a, b) -> a + b); // 15
int product = numberList.stream().reduce(1, (a, b) -> a * b); // 120

# 최댓값/최솟값

초깃값을 받지 않도록 오버로드된 reduce도 있다. 이 reduce는 Optional객체를 반환한다.

Optional<Integer> max = numberList.stream().reduce(Integer::max); // Optional[5]
Optional<Integer> min= numberList.stream().reduce(Integer::min); // Optional[1]

# 💎 숫자형 스트림

스트림 요소의 합을 구하는 예제가 아래와 같다.

int calories = menu.stream().map(Dish::getCalories).reduce(0, Integer::sum);

사실 위 코드에는 박싱 비용이 숨겨져 있다. 내부적으로 합계를 계산하기 전에 Integer를 기본형으로 언박싱해야한다. 직접 .sum() 메소드를 호출할 수 있다면 더 좋지 않을까?

다행히도 숫자 스트림을 효율적으로 처리할 수 있도록 기본형 특화 스트림을 제공한다.

# 기본형 특화 스트림

Java 8 에서는 IntStream DoubleStream LongStream 세가지 기본형 특화 스트림을 제공한다.

📌 숫자 스트림으로 매핑

int calories = menu.stream()
                .mapToInt(Dish::getCalories) //IntStream
                .sum();

📌 객체 스트림으로 복원하기

숫자 스트림을 만든 다음에 원상태인 특화되지 않은 스트림으로 복원할 수 있다.

IntStream intStream = menu.stream().mapToInt(Dish::getCalories);
Stream<Integer> stream = intStream.boxed();

📌 기본값: OptionalInt

합계 예제에서는 0이라는 기본값이 있으므로 별 문제가 없지만, 최댓값 예제에서는 잘못된 결과가 도출될 수도 있다. 이때, 값이 존재하는지 여부를 가리킬 수 있는 컨테이너 클래스 Optional을 활용한다. OptionalInt OptionalDouble OptionalLong 세가지 기본형 특화 스트림 버전도 제공한다.

OptionalInt maxCalories = menu.stream().mapToInt(Dish::getCalories).max();
int max = maxCalories.orElse(1); // 값이 없을 때 기본 최댓값을 명시적으로 설정

📌 숫자 범위

특정 범위의 숫자도 이용할 수 있다. IntStream과 LongStream에서는 range와 rangeClosed라는 두가지 정적 메서드를 제공한다. 첫번째 인수로 시작값을, 두번째 인수로 종료값을 갖는다.

IntStream evenNumbers = IntStream.rangeClosed(1, 100).filter(n -> n % 2 == 0);

# 💎 스트림 만들기

다양한 방식으로 스트림을 만드는 방법을 설명하자.

# 값으로 스트림 만들기 (Stream.of)

//MODERN
//JAVA
//IN
//ACTION
Stream<String> stream = Stream.of("Modern","Java","In","Action");
stream.map(String::toUpperCase).forEach(System.out::println);

Stream<String> emptyStream = Stream.empty(); // 스트림을 비울 수 있다.

# null이 될 수 있는 객체로 스트림 만들기 (Stream.ofNullable)

기존에는 다음처럼 null을 명시적으로 활용해야 했다.

String homeValue = System.getProperty("home");
Stream<String> homeValueStream
        = homeValue == null ? Stream.empty() : Stream.of(homeValue);

Stream.ofNullable을 이용해 다음처럼 코드를 구현할 수 있다.

Stream<String> homeValueStream
            = Stream.ofNullable(System.getProperty("home"));

# 배열로 스트림 만들기 (Arrays.stream)

기본형 int로 이루어진 배열을 IntStream으로 변환할 수 있다.

int[] numbers = {2, 3, 5, 7, 11, 13};
int sum = Arrays.stream(numbers).sum();

# 파일로 스트림 만들기

long uniqueWords = 0;
try (Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) {
    uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" ")))
            .distinct().count();
} catch (IOException e) {
    e.printStackTrace();
}

# 함수로 무한 스트림 만들기

무한 스트림을 만들 수 있는 두 정적 메서드 Stream.iterate Stream.generate를 제공한다.

📌 iterate

연속된 일련의 값을 만들 때는 iterate를 사용한다.

// 0
// 2
// 4
// 6
// 8
Stream.iterate(0, n -> n + 2).limit(5).forEach(System.out::println);

📌 generate

iterate과 달리 연속적으로 계산하지 않고, Supplier<T>를 인수로 받아 새로운 값을 생성한다.

// 0.19486211698371403
// 0.31687022682444055
// 0.5129741768745474
Stream.generate(Math::random).limit(3).forEach(System.out::println);

# Reference

모던 자바 인 액션 (한빛미디어)

← 🖤 03. 스트림 (Stream) | 특징 | 중간연산 | 최종연산 01. let & closure (for문 변수가 왜 바뀌지 않을까?) →